home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Special 26 / AMIGAplus Sonderheft 26 (2000)(Falke)(DE)(Track 1 of 2)[!].iso / Tools / GFX-Viewer / Animviewer / mpegvideo_datatype / mpegdecoders.c < prev    next >
C/C++ Source or Header  |  1999-03-29  |  30KB  |  854 lines
  1.  
  2. /*
  3. **
  4. **  $VER: mpegdecoders.c 1.8 (27.5.97)
  5. **  mpegvideo.datatype 1.8
  6. **
  7. **  This file contains all the routines for
  8. **  Huffman decoding required in MPEG
  9. **
  10. **  Written 1996 by Roland 'Gizzy' Mainz
  11. **
  12. */
  13.  
  14.  
  15. /* ansi includes */
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. /* project includes */
  20. #include "mpegproto.h"
  21. #include "mpegmyassert.h"
  22. #include "mpegdecoders.h"
  23. #include "mpegutil.h"
  24.  
  25. /* local prototypes
  26. static void init_mb_addr_inc(void);
  27. static void init_mb_type_P(void);
  28. static void init_mb_type_B(void);
  29. static void init_motion_vectors(void);
  30.  
  31. /* Decoding table for macroblock_address_increment */
  32. mb_addr_inc_entry     mb_addr_inc[ 2048 ];
  33.  
  34. /* Decoding table for macroblock_type in predictive-coded pictures */
  35. mb_type_entry         mb_type_P[ 64 ];
  36.  
  37. /* Decoding table for macroblock_type in bidirectionally-coded pictures */
  38. mb_type_entry         mb_type_B[ 64 ];
  39.  
  40. /* Decoding table for motion vectors */
  41. motion_vectors_entry  motion_vectors[ 2048 ];
  42.  
  43. /* Decoding table for coded_block_pattern */
  44. const
  45. coded_block_pattern_entry coded_block_pattern[ 512 ] =
  46. {
  47.     {ERROR, 0}, {ERROR, 0},
  48.                       {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9},
  49.     {58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8},
  50.     {57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8},
  51.     {38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8},
  52.     {43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8},
  53.     {42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8},
  54.     {41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8},
  55.     {35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, { 7, 8}, { 7, 8},
  56.     {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
  57.     {10, 7}, {10, 7}, {10, 7}, {10, 7}, { 6, 7}, { 6, 7}, { 6, 7}, { 6, 7},
  58.     {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
  59.     { 9, 7}, { 9, 7}, { 9, 7}, { 9, 7}, { 5, 7}, { 5, 7}, { 5, 7}, { 5, 7},
  60.     {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6},
  61.     { 3, 6}, {3,  6}, { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6}, { 3, 6},
  62.     {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6},
  63.     {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6},
  64.     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
  65.     {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
  66.     { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5},
  67.     { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5}, { 2, 5},
  68.     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
  69.     {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
  70.     { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5},
  71.     { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5}, { 1, 5},
  72.     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
  73.     {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
  74.     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
  75.     {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
  76.     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
  77.     {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
  78.     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
  79.     {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
  80.     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
  81.     {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
  82.     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
  83.     {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
  84.     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
  85.     {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
  86.     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
  87.     {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
  88.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
  89.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
  90.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
  91.     {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
  92.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
  93.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
  94.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
  95.     {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
  96.     { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4},
  97.     { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4},
  98.     { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4},
  99.     { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4}, { 8, 4},
  100.     { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4},
  101.     { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4},
  102.     { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4},
  103.     { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4}, { 4, 4},
  104.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  105.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  106.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  107.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  108.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  109.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  110.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
  111.     {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}
  112. };
  113.  
  114. /* Decoding table for dct_dc_size_luminance */
  115. const
  116. dct_dc_size_entry dct_dc_size_luminance[ 128 ] =
  117. {
  118.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  119.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  120.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  121.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
  122.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  123.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  124.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  125.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  126.     {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3},
  127.     {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3}, {0, 3},
  128.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
  129.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
  130.     {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3},
  131.     {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3}, {4, 3},
  132.     {5, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4}, {5, 4},
  133.     {6, 5}, {6, 5}, {6, 5}, {6, 5}, {7, 6}, {7, 6}, {8, 7}, {(unsigned int)ERROR, 0}
  134. };
  135.  
  136. /* Decoding table for dct_dc_size_chrominance */
  137. const
  138. dct_dc_size_entry dct_dc_size_chrominance[ 256 ] =
  139. {
  140.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
  141.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  142.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  143.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  144.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  145.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  146.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
  147.     {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, 
  148.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  149.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  150.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  151.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  152.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  153.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  154.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  155.     {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, 
  156.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  157.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  158.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  159.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  160.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
  161.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  162.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  163.     {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, 
  164.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, 
  165.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, 
  166.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, 
  167.     {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3}, 
  168.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, 
  169.     {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, 
  170.     {5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, {5, 5}, 
  171.     {6, 6}, {6, 6}, {6, 6}, {6, 6}, {7, 7}, {7, 7}, {8, 8}, {(unsigned int)ERROR, 0}
  172. };
  173.  
  174. /* DCT coeff tables. */
  175. const
  176. UWORD dct_coeff_tbl_0[ 256 ] =
  177. {
  178. 0xffff, 0xffff, 0xffff, 0xffff, 
  179. 0xffff, 0xffff, 0xffff, 0xffff, 
  180. 0xffff, 0xffff, 0xffff, 0xffff, 
  181. 0xffff, 0xffff, 0xffff, 0xffff, 
  182. 0x052f, 0x051f, 0x050f, 0x04ff, 
  183. 0x183f, 0x402f, 0x3c2f, 0x382f, 
  184. 0x342f, 0x302f, 0x2c2f, 0x7c1f, 
  185. 0x781f, 0x741f, 0x701f, 0x6c1f, 
  186. 0x028e, 0x028e, 0x027e, 0x027e, 
  187. 0x026e, 0x026e, 0x025e, 0x025e, 
  188. 0x024e, 0x024e, 0x023e, 0x023e, 
  189. 0x022e, 0x022e, 0x021e, 0x021e,
  190. 0x020e, 0x020e, 0x04ee, 0x04ee, 
  191. 0x04de, 0x04de, 0x04ce, 0x04ce,
  192. 0x04be, 0x04be, 0x04ae, 0x04ae, 
  193. 0x049e, 0x049e, 0x048e, 0x048e, 
  194. 0x01fd, 0x01fd, 0x01fd, 0x01fd, 
  195. 0x01ed, 0x01ed, 0x01ed, 0x01ed, 
  196. 0x01dd, 0x01dd, 0x01dd, 0x01dd, 
  197. 0x01cd, 0x01cd, 0x01cd, 0x01cd, 
  198. 0x01bd, 0x01bd, 0x01bd, 0x01bd, 
  199. 0x01ad, 0x01ad, 0x01ad, 0x01ad, 
  200. 0x019d, 0x019d, 0x019d, 0x019d, 
  201. 0x018d, 0x018d, 0x018d, 0x018d, 
  202. 0x017d, 0x017d, 0x017d, 0x017d, 
  203. 0x016d, 0x016d, 0x016d, 0x016d,
  204. 0x015d, 0x015d, 0x015d, 0x015d, 
  205. 0x014d, 0x014d, 0x014d, 0x014d, 
  206. 0x013d, 0x013d, 0x013d, 0x013d, 
  207. 0x012d, 0x012d, 0x012d, 0x012d, 
  208. 0x011d, 0x011d, 0x011d, 0x011d,
  209. 0x010d, 0x010d, 0x010d, 0x010d, 
  210. 0x282c, 0x282c, 0x282c, 0x282c, 
  211. 0x282c, 0x282c, 0x282c, 0x282c, 
  212. 0x242c, 0x242c, 0x242c, 0x242c, 
  213. 0x242c, 0x242c, 0x242c, 0x242c, 
  214. 0x143c, 0x143c, 0x143c, 0x143c, 
  215. 0x143c, 0x143c, 0x143c, 0x143c, 
  216. 0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c, 
  217. 0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c,
  218. 0x085c, 0x085c, 0x085c, 0x085c, 
  219. 0x085c, 0x085c, 0x085c, 0x085c, 
  220. 0x047c, 0x047c, 0x047c, 0x047c, 
  221. 0x047c, 0x047c, 0x047c, 0x047c, 
  222. 0x046c, 0x046c, 0x046c, 0x046c, 
  223. 0x046c, 0x046c, 0x046c, 0x046c, 
  224. 0x00fc, 0x00fc, 0x00fc, 0x00fc, 
  225. 0x00fc, 0x00fc, 0x00fc, 0x00fc,
  226. 0x00ec, 0x00ec, 0x00ec, 0x00ec, 
  227. 0x00ec, 0x00ec, 0x00ec, 0x00ec, 
  228. 0x00dc, 0x00dc, 0x00dc, 0x00dc, 
  229. 0x00dc, 0x00dc, 0x00dc, 0x00dc, 
  230. 0x00cc, 0x00cc, 0x00cc, 0x00cc, 
  231. 0x00cc, 0x00cc, 0x00cc, 0x00cc,
  232. 0x681c, 0x681c, 0x681c, 0x681c, 
  233. 0x681c, 0x681c, 0x681c, 0x681c, 
  234. 0x641c, 0x641c, 0x641c, 0x641c, 
  235. 0x641c, 0x641c, 0x641c, 0x641c, 
  236. 0x601c, 0x601c, 0x601c, 0x601c, 
  237. 0x601c, 0x601c, 0x601c, 0x601c, 
  238. 0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c, 
  239. 0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c, 
  240. 0x581c, 0x581c, 0x581c, 0x581c, 
  241. 0x581c, 0x581c, 0x581c, 0x581c, 
  242. };
  243.  
  244. const
  245. UWORD dct_coeff_tbl_1[ 16 ] =
  246. {
  247. 0x00bb, 0x202b, 0x103b, 0x00ab, 
  248. 0x084b, 0x1c2b, 0x541b, 0x501b, 
  249. 0x009b, 0x4c1b, 0x481b, 0x045b, 
  250. 0x0c3b, 0x008b, 0x182b, 0x441b, 
  251. };
  252.  
  253. const
  254. UWORD dct_coeff_tbl_2[ 4 ] =
  255. {
  256. 0x4019, 0x1429, 0x0079, 0x0839,
  257. };
  258.  
  259. const
  260. UWORD dct_coeff_tbl_3[ 4 ] =
  261. {
  262. 0x0449, 0x3c19, 0x3819, 0x1029,
  263. };
  264.  
  265. const
  266. UWORD dct_coeff_next[ 256 ] =
  267. {
  268. 0xffff, 0xffff, 0xffff, 0xffff,
  269. 0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5,
  270. 0x0826, 0x0826, 0x2416, 0x2416,
  271. 0x0046, 0x0046, 0x2016, 0x2016,
  272. 0x1c15, 0x1c15, 0x1c15, 0x1c15,
  273. 0x1815, 0x1815, 0x1815, 0x1815,
  274. 0x0425, 0x0425, 0x0425, 0x0425,
  275. 0x1415, 0x1415, 0x1415, 0x1415,
  276. 0x3417, 0x0067, 0x3017, 0x2c17,
  277. 0x0c27, 0x0437, 0x0057, 0x2817,
  278. 0x0034, 0x0034, 0x0034, 0x0034,
  279. 0x0034, 0x0034, 0x0034, 0x0034,
  280. 0x1014, 0x1014, 0x1014, 0x1014,
  281. 0x1014, 0x1014, 0x1014, 0x1014,
  282. 0x0c14, 0x0c14, 0x0c14, 0x0c14,
  283. 0x0c14, 0x0c14, 0x0c14, 0x0c14,
  284. 0x0023, 0x0023, 0x0023, 0x0023, 
  285. 0x0023, 0x0023, 0x0023, 0x0023, 
  286. 0x0023, 0x0023, 0x0023, 0x0023, 
  287. 0x0023, 0x0023, 0x0023, 0x0023, 
  288. 0x0813, 0x0813, 0x0813, 0x0813, 
  289. 0x0813, 0x0813, 0x0813, 0x0813, 
  290. 0x0813, 0x0813, 0x0813, 0x0813, 
  291. 0x0813, 0x0813, 0x0813, 0x0813,
  292. 0x0412, 0x0412, 0x0412, 0x0412, 
  293. 0x0412, 0x0412, 0x0412, 0x0412, 
  294. 0x0412, 0x0412, 0x0412, 0x0412, 
  295. 0x0412, 0x0412, 0x0412, 0x0412, 
  296. 0x0412, 0x0412, 0x0412, 0x0412, 
  297. 0x0412, 0x0412, 0x0412, 0x0412, 
  298. 0x0412, 0x0412, 0x0412, 0x0412, 
  299. 0x0412, 0x0412, 0x0412, 0x0412, 
  300. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  301. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  302. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  303. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  304. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  305. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
  306. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  307. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  308. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  309. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  310. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  311. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  312. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
  313. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  314. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  315. 0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1, 
  316. 0x0011, 0x0011, 0x0011, 0x0011, 
  317. 0x0011, 0x0011, 0x0011, 0x0011, 
  318. 0x0011, 0x0011, 0x0011, 0x0011, 
  319. 0x0011, 0x0011, 0x0011, 0x0011,
  320. 0x0011, 0x0011, 0x0011, 0x0011, 
  321. 0x0011, 0x0011, 0x0011, 0x0011, 
  322. 0x0011, 0x0011, 0x0011, 0x0011, 
  323. 0x0011, 0x0011, 0x0011, 0x0011, 
  324. 0x0011, 0x0011, 0x0011, 0x0011,
  325. 0x0011, 0x0011, 0x0011, 0x0011, 
  326. 0x0011, 0x0011, 0x0011, 0x0011, 
  327. 0x0011, 0x0011, 0x0011, 0x0011, 
  328. 0x0011, 0x0011, 0x0011, 0x0011, 
  329. 0x0011, 0x0011, 0x0011, 0x0011, 
  330. 0x0011, 0x0011, 0x0011, 0x0011, 
  331. 0x0011, 0x0011, 0x0011, 0x0011, 
  332. };
  333.  
  334. const
  335. UWORD dct_coeff_first[ 256 ] =
  336. {
  337. 0xffff, 0xffff, 0xffff, 0xffff,
  338. 0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5,
  339. 0x0826, 0x0826, 0x2416, 0x2416,
  340. 0x0046, 0x0046, 0x2016, 0x2016,
  341. 0x1c15, 0x1c15, 0x1c15, 0x1c15,
  342. 0x1815, 0x1815, 0x1815, 0x1815,
  343. 0x0425, 0x0425, 0x0425, 0x0425, 
  344. 0x1415, 0x1415, 0x1415, 0x1415, 
  345. 0x3417, 0x0067, 0x3017, 0x2c17, 
  346. 0x0c27, 0x0437, 0x0057, 0x2817, 
  347. 0x0034, 0x0034, 0x0034, 0x0034, 
  348. 0x0034, 0x0034, 0x0034, 0x0034,
  349. 0x1014, 0x1014, 0x1014, 0x1014, 
  350. 0x1014, 0x1014, 0x1014, 0x1014, 
  351. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  352. 0x0c14, 0x0c14, 0x0c14, 0x0c14, 
  353. 0x0023, 0x0023, 0x0023, 0x0023, 
  354. 0x0023, 0x0023, 0x0023, 0x0023, 
  355. 0x0023, 0x0023, 0x0023, 0x0023, 
  356. 0x0023, 0x0023, 0x0023, 0x0023, 
  357. 0x0813, 0x0813, 0x0813, 0x0813, 
  358. 0x0813, 0x0813, 0x0813, 0x0813, 
  359. 0x0813, 0x0813, 0x0813, 0x0813, 
  360. 0x0813, 0x0813, 0x0813, 0x0813, 
  361. 0x0412, 0x0412, 0x0412, 0x0412, 
  362. 0x0412, 0x0412, 0x0412, 0x0412,
  363. 0x0412, 0x0412, 0x0412, 0x0412, 
  364. 0x0412, 0x0412, 0x0412, 0x0412, 
  365. 0x0412, 0x0412, 0x0412, 0x0412, 
  366. 0x0412, 0x0412, 0x0412, 0x0412, 
  367. 0x0412, 0x0412, 0x0412, 0x0412, 
  368. 0x0412, 0x0412, 0x0412, 0x0412, 
  369. 0x0010, 0x0010, 0x0010, 0x0010, 
  370. 0x0010, 0x0010, 0x0010, 0x0010, 
  371. 0x0010, 0x0010, 0x0010, 0x0010,
  372. 0x0010, 0x0010, 0x0010, 0x0010, 
  373. 0x0010, 0x0010, 0x0010, 0x0010, 
  374. 0x0010, 0x0010, 0x0010, 0x0010, 
  375. 0x0010, 0x0010, 0x0010, 0x0010, 
  376. 0x0010, 0x0010, 0x0010, 0x0010,
  377. 0x0010, 0x0010, 0x0010, 0x0010, 
  378. 0x0010, 0x0010, 0x0010, 0x0010, 
  379. 0x0010, 0x0010, 0x0010, 0x0010,
  380. 0x0010, 0x0010, 0x0010, 0x0010, 
  381. 0x0010, 0x0010, 0x0010, 0x0010, 
  382. 0x0010, 0x0010, 0x0010, 0x0010, 
  383. 0x0010, 0x0010, 0x0010, 0x0010, 
  384. 0x0010, 0x0010, 0x0010, 0x0010, 
  385. 0x0010, 0x0010, 0x0010, 0x0010, 
  386. 0x0010, 0x0010, 0x0010, 0x0010, 
  387. 0x0010, 0x0010, 0x0010, 0x0010,
  388. 0x0010, 0x0010, 0x0010, 0x0010, 
  389. 0x0010, 0x0010, 0x0010, 0x0010, 
  390. 0x0010, 0x0010, 0x0010, 0x0010,
  391. 0x0010, 0x0010, 0x0010, 0x0010, 
  392. 0x0010, 0x0010, 0x0010, 0x0010, 
  393. 0x0010, 0x0010, 0x0010, 0x0010, 
  394. 0x0010, 0x0010, 0x0010, 0x0010, 
  395. 0x0010, 0x0010, 0x0010, 0x0010,
  396. 0x0010, 0x0010, 0x0010, 0x0010, 
  397. 0x0010, 0x0010, 0x0010, 0x0010, 
  398. 0x0010, 0x0010, 0x0010, 0x0010, 
  399. 0x0010, 0x0010, 0x0010, 0x0010, 
  400. 0x0010, 0x0010, 0x0010, 0x0010,
  401. };
  402.  
  403. /* Macro for filling up the decoding table for mb_addr_inc */
  404. #define ASSIGN1( start, end, step, val, num ) \
  405.   for( i = start ; i < end ; i+= step )       \
  406.   {                                           \
  407.     for( j = 0 ; j < step ; j++ )             \
  408.     {                                         \
  409.       mb_addr_inc[ i + j ] . value    = val;  \
  410.       mb_addr_inc[ i + j ] . num_bits = num;  \
  411.     }                                         \
  412.                                               \
  413.     val--;                                    \
  414.   }
  415.  
  416.  
  417.  
  418. /*
  419.  *--------------------------------------------------------------
  420.  *
  421.  * init_mb_addr_inc --
  422.  *
  423.  *    Initialize the VLC decoding table for macro_block_address_increment
  424.  *
  425.  * Results:
  426.  *    The decoding table for macro_block_address_increment will
  427.  *      be filled; illegal values will be filled as ERROR.
  428.  *
  429.  * Side effects:
  430.  *    The global array mb_addr_inc will be filled.
  431.  *
  432.  *--------------------------------------------------------------
  433.  */
  434.  
  435.  
  436. static
  437. void init_mb_addr_inc( void )
  438. {
  439.     int i, j, val;
  440.  
  441.     for( i = 0 ; i < 8 ; i++ )
  442.     {
  443.       mb_addr_inc[ i ] . value    = ERROR;
  444.       mb_addr_inc[ i ] . num_bits = 0;
  445.     }
  446.  
  447.     mb_addr_inc[ 8 ] . value    = MACRO_BLOCK_ESCAPE;
  448.     mb_addr_inc[ 8 ] . num_bits = 11;
  449.  
  450.     for( i = 9 ; i < 15 ; i++ )
  451.     {
  452.       mb_addr_inc[ i ] . value = ERROR;
  453.       mb_addr_inc[ i ] . num_bits = 0;
  454.     }
  455.  
  456.     mb_addr_inc[ 15 ] . value     = MACRO_BLOCK_STUFFING;
  457.     mb_addr_inc[ 15 ] . num_bits  = 11;
  458.  
  459.     for( i = 16 ; i < 24 ; i++ )
  460.     {
  461.       mb_addr_inc[ i ] . value    = ERROR;
  462.       mb_addr_inc[ i ] . num_bits = 0;
  463.     }
  464.  
  465.     val = 33;
  466.  
  467.     ASSIGN1(   24,   36,    1, val, 11 )
  468.     ASSIGN1(   36,   48,    2, val, 10 )
  469.     ASSIGN1(   48,   96,    8, val,  8 )
  470.     ASSIGN1(   96,  128,   16, val,  7 )
  471.     ASSIGN1(  128,  256,   64, val,  5 )
  472.     ASSIGN1(  256,  512,  128, val,  4 )
  473.     ASSIGN1(  512, 1024,  256, val,  3 )
  474.     ASSIGN1( 1024, 2048, 1024, val,  1 )
  475. }
  476.  
  477.  
  478. /* Macro for filling up the decoding table for mb_type */
  479. #define ASSIGN2( start, end, quant, motion_forward, motion_backward, pattern, intra, num, mb_type ) \
  480.   for( i = start ; i < end ; i ++ )                        \
  481.   {                                                        \
  482.     mb_type[ i ] . mb_quant             = quant;           \
  483.     mb_type[ i ] . mb_motion_forward    = motion_forward;  \
  484.     mb_type[ i ] . mb_motion_backward   = motion_backward; \
  485.     mb_type[ i ] . mb_pattern           = pattern;         \
  486.     mb_type[ i ] . mb_intra             = intra;           \
  487.     mb_type[ i ] . num_bits             = num;             \
  488.   }                                                        \
  489.  
  490.  
  491.  
  492. /*
  493.  *--------------------------------------------------------------
  494.  *
  495.  * init_mb_type_P --
  496.  *
  497.  *    Initialize the VLC decoding table for macro_block_type in
  498.  *      predictive-coded pictures.
  499.  *
  500.  * Results:
  501.  *    The decoding table for macro_block_type in predictive-coded
  502.  *      pictures will be filled; illegal values will be filled as ERROR.
  503.  *
  504.  * Side effects:
  505.  *    The global array mb_type_P will be filled.
  506.  *
  507.  *--------------------------------------------------------------
  508.  */
  509.  
  510.  
  511. static
  512. void init_mb_type_P( void )
  513. {
  514.     int i;
  515.  
  516.     mb_type_P[ 0 ] . mb_quant               =
  517.       mb_type_P[ 0 ] . mb_motion_forward    =
  518.       mb_type_P[ 0 ] . mb_motion_backward   =
  519.       mb_type_P[ 0 ] . mb_pattern           =
  520.       mb_type_P[ 0 ] . mb_intra             = ERROR;
  521.     mb_type_P[ 0 ] . num_bits               = 0;
  522.  
  523.     ASSIGN2(  1,  2, 1, 0, 0, 0, 1, 6, mb_type_P )
  524.     ASSIGN2(  2,  4, 1, 0, 0, 1, 0, 5, mb_type_P )
  525.     ASSIGN2(  4,  6, 1, 1, 0, 1, 0, 5, mb_type_P )
  526.     ASSIGN2(  6,  8, 0, 0, 0, 0, 1, 5, mb_type_P )
  527.     ASSIGN2(  8, 16, 0, 1, 0, 0, 0, 3, mb_type_P )
  528.     ASSIGN2( 16, 32, 0, 0, 0, 1, 0, 2, mb_type_P )
  529.     ASSIGN2( 32, 64, 0, 1, 0, 1, 0, 1, mb_type_P )
  530. }
  531.  
  532.  
  533. /*
  534.  *--------------------------------------------------------------
  535.  *
  536.  * init_mb_type_B --
  537.  *
  538.  *    Initialize the VLC decoding table for macro_block_type in
  539.  *      bidirectionally-coded pictures.
  540.  *
  541.  * Results:
  542.  *    The decoding table for macro_block_type in bidirectionally-coded
  543.  *      pictures will be filled; illegal values will be filled as ERROR.
  544.  *
  545.  * Side effects:
  546.  *    The global array mb_type_B will be filled.
  547.  *
  548.  *--------------------------------------------------------------
  549.  */
  550.  
  551.  
  552. static
  553. void init_mb_type_B( void )
  554. {
  555.     int i;
  556.  
  557.     mb_type_B[ 0 ] . mb_quant             =
  558.       mb_type_B[ 0 ] . mb_motion_forward  =
  559.       mb_type_B[ 0 ] . mb_motion_backward =
  560.       mb_type_B[ 0 ] . mb_pattern         =
  561.       mb_type_B[ 0 ] . mb_intra           = ERROR;
  562.     mb_type_B[ 0 ] . num_bits             = 0;
  563.  
  564.     ASSIGN2(  1,  2, 1, 0, 0, 0, 1, 6, mb_type_B );
  565.     ASSIGN2(  2,  3, 1, 0, 1, 1, 0, 6, mb_type_B );
  566.     ASSIGN2(  3,  4, 1, 1, 0, 1, 0, 6, mb_type_B );
  567.     ASSIGN2(  4,  6, 1, 1, 1, 1, 0, 5, mb_type_B );
  568.     ASSIGN2(  6,  8, 0, 0, 0, 0, 1, 5, mb_type_B );
  569.     ASSIGN2(  8, 12, 0, 1, 0, 0, 0, 4, mb_type_B );
  570.     ASSIGN2( 12, 16, 0, 1, 0, 1, 0, 4, mb_type_B );
  571.     ASSIGN2( 16, 24, 0, 0, 1, 0, 0, 3, mb_type_B );
  572.     ASSIGN2( 24, 32, 0, 0, 1, 1, 0, 3, mb_type_B );
  573.     ASSIGN2( 32, 48, 0, 1, 1, 0, 0, 2, mb_type_B );
  574.     ASSIGN2( 48, 64, 0, 1, 1, 1, 0, 2, mb_type_B );
  575. }
  576.  
  577.  
  578. /* Macro for filling up the decoding tables for motion_vectors */
  579. #define ASSIGN3( start, end, step, val, num )       \
  580.   for( i = start; i < end; i+= step )               \
  581.   {                                                 \
  582.     for( j = 0 ; j < step / 2 ; j++ )               \
  583.     {                                               \
  584.       motion_vectors[ i +j ] . code     = val;      \
  585.       motion_vectors[ i +j ] . num_bits = num;      \
  586.     }                                               \
  587.                                                     \
  588.     for( j = step / 2 ; j < step ; j++ )            \
  589.     {                                               \
  590.       motion_vectors[ i + j ] . code     = -val;    \
  591.       motion_vectors[ i + j ] . num_bits = num;     \
  592.     }                                               \
  593.                                                     \
  594.     val--;                                          \
  595.   }
  596.  
  597.  
  598.  
  599. /*
  600.  *--------------------------------------------------------------
  601.  *
  602.  * init_motion_vectors --
  603.  *
  604.  *    Initialize the VLC decoding table for the various motion
  605.  *      vectors, including motion_horizontal_forward_code, 
  606.  *      motion_vertical_forward_code, motion_horizontal_backward_code,
  607.  *      and motion_vertical_backward_code.
  608.  *
  609.  * Results:
  610.  *    The decoding table for the motion vectors will be filled;
  611.  *      illegal values will be filled as ERROR.
  612.  *
  613.  * Side effects:
  614.  *    The global array motion_vector will be filled.
  615.  *
  616.  *--------------------------------------------------------------
  617.  */
  618.  
  619.  
  620. static
  621. void init_motion_vectors( void )
  622. {
  623.   int i, j, val = 16;
  624.  
  625.   for( i = 0 ; i < 24 ; i++ )
  626.   {
  627.     motion_vectors[ i ] . code      = ERROR;
  628.     motion_vectors[ i ] . num_bits  = 0;
  629.   }
  630.  
  631.   ASSIGN3(   24,   36,    2, val, 11 );
  632.   ASSIGN3(   36,   48,    4, val, 10 );
  633.   ASSIGN3(   48,   96,   16, val,  8 );
  634.   ASSIGN3(   96,  128,   32, val,  7 );
  635.   ASSIGN3(  128,  256,  128, val,  5 );
  636.   ASSIGN3(  256,  512,  256, val,  4 );
  637.   ASSIGN3(  512, 1024,  512, val,  3 );
  638.   ASSIGN3( 1024, 2048, 1024, val,  1 );
  639. }
  640.  
  641.  
  642. /*
  643.  *--------------------------------------------------------------
  644.  *
  645.  * init_tables --
  646.  *
  647.  *    Initialize all the tables for VLC decoding; this must be
  648.  *      called when the system is set up before any decoding can
  649.  *      take place.
  650.  *
  651.  * Results:
  652.  *    All the decoding tables will be filled accordingly.
  653.  *
  654.  * Side effects:
  655.  *    The corresponding global array for each decoding table
  656.  *      will be filled.
  657.  *
  658.  *--------------------------------------------------------------
  659.  */
  660.  
  661.  
  662. void init_tables( void )
  663. {
  664.     init_mb_addr_inc();
  665.     init_mb_type_P();
  666.     init_mb_type_B();
  667.     init_motion_vectors();
  668.  
  669. #ifdef FLOATDCT
  670.     init_float_idct();
  671. #endif
  672.     init_pre_idct();
  673. }
  674.  
  675.  
  676. /*
  677.  *--------------------------------------------------------------
  678.  *
  679.  * DecodeDCTDCSizeLum --
  680.  *
  681.  *    Huffman Decoder for dct_dc_size_luminance; location where
  682.  *      the result of decoding will be placed is passed as argument.
  683.  *      The decoded values are obtained by doing a table lookup on
  684.  *      dct_dc_size_luminance.
  685.  *
  686.  * Results:
  687.  *    The decoded value for dct_dc_size_luminance or ERROR for
  688.  *      unbound values will be placed in the location specified.
  689.  *
  690.  * Side effects:
  691.  *    Bit stream is irreversibly parsed.
  692.  *
  693.  *--------------------------------------------------------------
  694.  */
  695.  
  696.  
  697. void decodeDCTDCSizeLum( struct MPEGVideoInstData *mvid, unsigned int *value )
  698. {
  699.     unsigned int index;
  700.  
  701.     show_bits7( index );
  702.  
  703.     *value = dct_dc_size_luminance[ index ] . value;
  704.  
  705.     flush_bits( dct_dc_size_luminance[ index ] . num_bits );
  706. }
  707.  
  708.  
  709. /*
  710.  *--------------------------------------------------------------
  711.  *
  712.  * DecodeDCTDCSizeChrom --
  713.  *
  714.  *    Huffman Decoder for dct_dc_size_chrominance; location where
  715.  *      the result of decoding will be placed is passed as argument.
  716.  *      The decoded values are obtained by doing a table lookup on
  717.  *      dct_dc_size_chrominance.
  718.  *
  719.  * Results:
  720.  *    The decoded value for dct_dc_size_chrominance or ERROR for
  721.  *      unbound values will be placed in the location specified.
  722.  *
  723.  * Side effects:
  724.  *    Bit stream is irreversibly parsed.
  725.  *
  726.  *--------------------------------------------------------------
  727.  */
  728.  
  729.  
  730. void decodeDCTDCSizeChrom( struct MPEGVideoInstData *mvid, unsigned int *value )
  731. {
  732.     unsigned int index;
  733.  
  734.     show_bits8( index );
  735.  
  736.     *value = dct_dc_size_chrominance[ index ] . value;
  737.  
  738.     flush_bits( dct_dc_size_chrominance[ index ] . num_bits );
  739. }
  740.  
  741.  
  742. /*
  743.  *--------------------------------------------------------------
  744.  *
  745.  * decodeDCTCoeff --
  746.  *
  747.  *    Huffman Decoder for dct_coeff_first and dct_coeff_next;
  748.  *      locations where the results of decoding: run and level, are to
  749.  *      be placed and also the type of DCT coefficients, either
  750.  *      dct_coeff_first or dct_coeff_next, are being passed as argument.
  751.  *      
  752.  *      The decoder first examines the next 8 bits in the input stream,
  753.  *      and perform according to the following cases:
  754.  *      
  755.  *      '0000 0000' - examine 8 more bits (i.e. 16 bits total) and
  756.  *                    perform a table lookup on dct_coeff_tbl_0.
  757.  *                    One more bit is then examined to determine the sign
  758.  *                    of level.
  759.  *
  760.  *      '0000 0001' - examine 4 more bits (i.e. 12 bits total) and
  761.  *                    perform a table lookup on dct_coeff_tbl_1.
  762.  *                    One more bit is then examined to determine the sign
  763.  *                    of level.
  764.  *
  765.  *      '0000 0010' - examine 2 more bits (i.e. 10 bits total) and
  766.  *                    perform a table lookup on dct_coeff_tbl_2.
  767.  *                    One more bit is then examined to determine the sign
  768.  *                    of level.
  769.  *
  770.  *      '0000 0011' - examine 2 more bits (i.e. 10 bits total) and
  771.  *                    perform a table lookup on dct_coeff_tbl_3.
  772.  *                    One more bit is then examined to determine the sign
  773.  *                    of level.
  774.  *
  775.  *      otherwise   - perform a table lookup on dct_coeff_tbl. If the
  776.  *                    value of run is not ESCAPE, extract one more bit
  777.  *                    to determine the sign of level; otherwise 6 more
  778.  *                    bits will be extracted to obtain the actual value 
  779.  *                    of run , and then 8 or 16 bits to get the value of level.
  780.  *
  781.  *      
  782.  *
  783.  * Results:
  784.  *    The decoded values of run and level or ERROR for unbound values
  785.  *      are placed in the locations specified.
  786.  *
  787.  * Side effects:
  788.  *    Bit stream is irreversibly parsed.
  789.  *
  790.  *--------------------------------------------------------------
  791.  */
  792.  
  793.  
  794. void decodeDCTCoeff( struct MPEGVideoInstData *mvid, const UWORD *dct_coeff_tbl, unsigned int *run, int *level )
  795. {
  796.     DecodeDCTCoeff( dct_coeff_tbl, (*run), (*level) );
  797. }
  798.  
  799.  
  800. /*
  801.  *--------------------------------------------------------------
  802.  *
  803.  * decodeDCTCoeffFirst --
  804.  *
  805.  *    Huffman Decoder for dct_coeff_first. Locations for the
  806.  *      decoded results: run and level, are being passed as
  807.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  808.  *      with the table dct_coeff_first.
  809.  *
  810.  * Results:
  811.  *    The decoded values of run and level for dct_coeff_first or
  812.  *      ERROR for unbound values are placed in the locations given.
  813.  *
  814.  * Side effects:
  815.  *    Bit stream is irreversibly parsed.
  816.  *
  817.  *--------------------------------------------------------------
  818.  */
  819.  
  820.  
  821. void decodeDCTCoeffFirst( struct MPEGVideoInstData *mvid, unsigned int *run, int *level )
  822. {
  823.     decodeDCTCoeff( mvid, dct_coeff_first, run, level );
  824. }
  825.  
  826.  
  827. /*
  828.  *--------------------------------------------------------------
  829.  *
  830.  * decodeDCTCoeffNext --
  831.  *
  832.  *    Huffman Decoder for dct_coeff_first. Locations for the
  833.  *      decoded results: run and level, are being passed as
  834.  *      arguments. Actual work is being done by calling DecodeDCTCoeff,
  835.  *      with the table dct_coeff_next.
  836.  *
  837.  * Results:
  838.  *    The decoded values of run and level for dct_coeff_next or
  839.  *      ERROR for unbound values are placed in the locations given.
  840.  *
  841.  * Side effects:
  842.  *    Bit stream is irreversibly parsed.
  843.  *
  844.  *--------------------------------------------------------------
  845.  */
  846.  
  847.  
  848. void decodeDCTCoeffNext( struct MPEGVideoInstData *mvid, unsigned int *run, int *level )
  849. {
  850.     decodeDCTCoeff( mvid, dct_coeff_next, run, level );
  851. }
  852.  
  853.  
  854.